home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / ScanTabs.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  20KB  |  747 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Checks
  4. #include "Checks.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_General
  8. #include "General.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Memory
  12. #include "Memory.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_DynArray
  16. #include "DynArray.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Strings
  20. #include "Strings.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Sets
  28. #include "Sets.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_System
  32. #include "System.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_IO
  36. #include "IO.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Layout
  40. #include "Layout.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Dfa
  44. #include "Dfa.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_GenTabs
  48. #include "GenTabs.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Classes
  52. #include "Classes.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_ScanGen
  56. #include "ScanGen.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_ScanTabs
  60. #include "ScanTabs.h"
  61. #endif
  62.  
  63. ScanTabs_RuleBase *ScanTabs_RuleBasePtr;
  64. LONGINT ScanTabs_RuleBaseSize;
  65. ScanTabs_Rule *ScanTabs_RulePtr;
  66. LONGINT ScanTabs_RuleSize;
  67. ScanTabs_Base *ScanTabs_BasePtr;
  68. LONGINT ScanTabs_BaseSize;
  69. ScanTabs_Default *ScanTabs_DefaultPtr;
  70. LONGINT ScanTabs_DefaultSize;
  71. ScanTabs_Control *ScanTabs_ControlPtr;
  72. LONGINT ScanTabs_ControlSize;
  73. ScanTabs_EobTrans *ScanTabs_EobTransPtr;
  74. LONGINT ScanTabs_EobTransSize;
  75. ScanTabs_Context *ScanTabs_ContextPtr;
  76. LONGINT ScanTabs_ContextSize;
  77. ScanTabs_Action *ScanTabs_ActionPtr;
  78. LONGINT ScanTabs_ActionSize;
  79. ScanTabs_ActionType ScanTabs_ActionNr;
  80. ScanTabs_TableRange ScanTabs_TableSize;
  81. ScanTabs_TableRange ScanTabs_TableEntries;
  82.  
  83. static System_tFile Tables;
  84. static ScanTabs_TableElmt ElmtSize;
  85. struct S_2 {
  86.     CHAR A[127 + 1];
  87. };
  88. static void PutTable ARGS((ScanTabs_TableElmt Length, ADDRESS Address));
  89. typedef struct S_1 *DiffsInfoPtr;
  90. typedef struct S_1 {
  91.     struct S_3 {
  92.         CHAR A[256 - 1 + 1];
  93.     } *DiffsPtr;
  94.     DiffsInfoPtr Next;
  95.     ScanTabs_TableRange Base;
  96.     SHORTCARD Count;
  97. } DiffsInfo;
  98. struct S_4 {
  99.     struct S_5 {
  100.         CHAR First, Last;
  101.     } A[128 + 1];
  102. };
  103. struct S_6 {
  104.     CHAR A[256 + 1];
  105. };
  106. struct S_7 {
  107.     DiffsInfoPtr A[100000 + 1];
  108. };
  109. static void WriteState ARGS((Dfa_DStateRange State));
  110.  
  111.  
  112. void ScanTabs_PutTables
  113. # ifdef __STDC__
  114. (BOOLEAN ReduceCaseSize)
  115. # else
  116. (ReduceCaseSize)
  117. BOOLEAN ReduceCaseSize;
  118. # endif
  119. {
  120.   CARDINAL BlockSize, i;
  121.   ScanTabs_StateRange StateCount;
  122.   Strings_tString FileNameS, PathS;
  123.   struct S_2 PathA;
  124.  
  125.   BlockSize = 64000 / sizeof(ScanTabs_ControlType);
  126.   StateCount = Dfa_DStateCount;
  127.   if (ScanGen_ScannerName == Idents_NoIdent) {
  128.     Strings_ArrayToString((STRING)"Scanner", 7L, &PathS);
  129.   } else {
  130.     Idents_GetString(ScanGen_ScannerName, &PathS);
  131.   }
  132.   Strings_ArrayToString((STRING)".Tab", 4L, &FileNameS);
  133.   Strings_Concatenate(&PathS, &FileNameS);
  134.   Strings_Append(&PathS, '\0');
  135.   Strings_StringToArray(&PathS, PathA.A, 128L);
  136.   Tables = OpenOutput(PathA.A, 128L);
  137.   Checks_ErrorCheck((STRING)"PutTables.OpenOutput", 20L, Tables);
  138.   PutTable((StateCount + 1) * ElmtSize, (ADDRESS)ScanTabs_BasePtr);
  139.   PutTable((StateCount + 1) * ElmtSize, (ADDRESS)ScanTabs_DefaultPtr);
  140.   PutTable((StateCount + 1) * ElmtSize, (ADDRESS)ScanTabs_EobTransPtr);
  141.   if (ReduceCaseSize) {
  142.     PutTable((StateCount + 1) * ElmtSize, (ADDRESS)ScanTabs_ActionPtr);
  143.   }
  144.   i = 0;
  145.   while (i <= ScanTabs_TableSize) {
  146.     PutTable((SHORTCARD)(General_Min((LONGINT)BlockSize, (LONGINT)(ScanTabs_TableSize + 1 - i)) * sizeof(ScanTabs_ControlType)), ADR(ScanTabs_ControlPtr->A[i]));
  147.     INC1(i, BlockSize);
  148.   }
  149. }
  150.  
  151. static void PutTable
  152. # ifdef __STDC__
  153. (ScanTabs_TableElmt Length, ADDRESS Address)
  154. # else
  155. (Length, Address)
  156. ScanTabs_TableElmt Length;
  157. ADDRESS Address;
  158. # endif
  159. {
  160.   INTEGER N;
  161.  
  162.   N = Write(Tables, ADR(Length), (LONGCARD)ElmtSize);
  163.   Checks_ErrorCheck((STRING)"PutTable.Write1", 15L, N);
  164.   N = Write(Tables, Address, (LONGCARD)Length);
  165.   Checks_ErrorCheck((STRING)"PutTable.Write2", 15L, N);
  166. }
  167.  
  168. void ScanTabs_PutComb
  169. # ifdef __STDC__
  170. (System_tFile File)
  171. # else
  172. (File)
  173. System_tFile File;
  174. # endif
  175. {
  176.   ScanTabs_TableRange i;
  177.  
  178.   {
  179.     LONGCARD B_1 = 1, B_2 = ScanTabs_TableSize;
  180.  
  181.     if (B_1 <= B_2)
  182.       for (i = B_1;; i += 1) {
  183.         IO_WriteC(File, '{');
  184.         IO_WriteI(File, (LONGINT)ScanTabs_ControlPtr->A[i].Check, 0L);
  185.         IO_WriteS(File, (STRING)", ", 2L);
  186.         IO_WriteI(File, (LONGINT)ScanTabs_ControlPtr->A[i].Next, 0L);
  187.         IO_WriteS(File, (STRING)"},", 2L);
  188.         IO_WriteNl(File);
  189.         if (i >= B_2) break;
  190.       }
  191.   }
  192. }
  193.  
  194. void ScanTabs_PutBase
  195. # ifdef __STDC__
  196. (System_tFile File)
  197. # else
  198. (File)
  199. System_tFile File;
  200. # endif
  201. {
  202.   INTEGER i;
  203.  
  204.   {
  205.     LONGINT B_3 = 1, B_4 = Dfa_DStateCount;
  206.  
  207.     if (B_3 <= B_4)
  208.       for (i = B_3;; i += 1) {
  209.         IO_WriteS(File, (STRING)"& yyComb [", 10L);
  210.         IO_WriteI(File, (LONGINT)ScanTabs_BasePtr->A[i], 0L);
  211.         IO_WriteS(File, (STRING)"],", 2L);
  212.         IO_WriteNl(File);
  213.         if (i >= B_4) break;
  214.       }
  215.   }
  216. }
  217.  
  218. void ScanTabs_PutDefault
  219. # ifdef __STDC__
  220. (System_tFile File)
  221. # else
  222. (File)
  223. System_tFile File;
  224. # endif
  225. {
  226.   INTEGER i;
  227.  
  228.   {
  229.     LONGINT B_5 = 1, B_6 = Dfa_DStateCount;
  230.  
  231.     if (B_5 <= B_6)
  232.       for (i = B_5;; i += 1) {
  233.         IO_WriteI(File, (LONGINT)ScanTabs_DefaultPtr->A[i], 0L);
  234.         IO_WriteC(File, ',');
  235.         IO_WriteNl(File);
  236.         if (i >= B_6) break;
  237.       }
  238.   }
  239. }
  240.  
  241. void ScanTabs_PutEobTrans
  242. # ifdef __STDC__
  243. (System_tFile File)
  244. # else
  245. (File)
  246. System_tFile File;
  247. # endif
  248. {
  249.   INTEGER i;
  250.  
  251.   {
  252.     LONGINT B_7 = 1, B_8 = Dfa_DStateCount;
  253.  
  254.     if (B_7 <= B_8)
  255.       for (i = B_7;; i += 1) {
  256.         IO_WriteI(File, (LONGINT)ScanTabs_EobTransPtr->A[i], 0L);
  257.         IO_WriteC(File, ',');
  258.         IO_WriteNl(File);
  259.         if (i >= B_8) break;
  260.       }
  261.   }
  262. }
  263.  
  264. void ScanTabs_PutAction
  265. # ifdef __STDC__
  266. (System_tFile File)
  267. # else
  268. (File)
  269. System_tFile File;
  270. # endif
  271. {
  272.   INTEGER i;
  273.  
  274.   {
  275.     LONGINT B_9 = 1, B_10 = Dfa_DStateCount;
  276.  
  277.     if (B_9 <= B_10)
  278.       for (i = B_9;; i += 1) {
  279.         IO_WriteI(File, (LONGINT)ScanTabs_ActionPtr->A[i], 0L);
  280.         IO_WriteC(File, ',');
  281.         IO_WriteNl(File);
  282.         if (i >= B_10) break;
  283.       }
  284.   }
  285. }
  286.  
  287. void ScanTabs_MakeTables
  288. # ifdef __STDC__
  289. (BOOLEAN ReduceCaseSize)
  290. # else
  291. (ReduceCaseSize)
  292. BOOLEAN ReduceCaseSize;
  293. # endif
  294. {
  295.   Dfa_DStateRange State;
  296.   CARDINAL cState;
  297.   SHORTCARD Pattern;
  298.  
  299.   ScanTabs_DefaultSize = Dfa_DStateCount + 1;
  300.   DynArray_MakeArray((ADDRESS *)&ScanTabs_DefaultPtr, &ScanTabs_DefaultSize, (LONGINT)sizeof(ScanTabs_StateRange));
  301.   DynArray_MakeArray((ADDRESS *)&ScanTabs_EobTransPtr, &ScanTabs_DefaultSize, (LONGINT)sizeof(ScanTabs_StateRange));
  302.   ScanTabs_DefaultPtr->A[Dfa_DNoState] = Dfa_DNoState;
  303.   ScanTabs_EobTransPtr->A[Dfa_DNoState] = Dfa_DNoState;
  304.   {
  305.     SHORTINT B_11 = 1, B_12 = Dfa_DStateCount;
  306.  
  307.     if (B_11 <= B_12)
  308.       for (State = B_11;; State += 1) {
  309.         ScanTabs_DefaultPtr->A[State] = Dfa_GetDefault(State);
  310.         ScanTabs_EobTransPtr->A[State] = Dfa_GetEobTrans(State);
  311.         if (State >= B_12) break;
  312.       }
  313.   }
  314.   if (ReduceCaseSize) {
  315.     DynArray_MakeArray((ADDRESS *)&ScanTabs_ActionPtr, &ScanTabs_DefaultSize, (LONGINT)sizeof(ScanTabs_TableElmt));
  316.     ScanTabs_ActionPtr->A[Dfa_DNoState] = Dfa_DNoState;
  317.     {
  318.       SHORTINT B_13 = 1, B_14 = Dfa_DStateCount;
  319.  
  320.       if (B_13 <= B_14)
  321.         for (State = B_13;; State += 1) {
  322.           ScanTabs_ActionPtr->A[State] = GenTabs_PatternCount + 1;
  323.           if (State >= B_14) break;
  324.         }
  325.     }
  326.     {
  327.       SHORTCARD B_15 = 1, B_16 = GenTabs_PatternCount;
  328.  
  329.       if (B_15 <= B_16)
  330.         for (Pattern = B_15;; Pattern += 1) {
  331.           {
  332.             LONGCARD B_17 = Sets_Minimum(&GenTabs_PatternTablePtr->A[Pattern].Finals), B_18 = Sets_Maximum(&GenTabs_PatternTablePtr->A[Pattern].Finals);
  333.  
  334.             if (B_17 <= B_18)
  335.               for (cState = B_17;; cState += 1) {
  336.                 if (Sets_IsElement(cState, &GenTabs_PatternTablePtr->A[Pattern].Finals)) {
  337.                   ScanTabs_ActionPtr->A[cState] = Pattern;
  338.                 }
  339.                 if (cState >= B_18) break;
  340.               }
  341.           }
  342.           if (Pattern >= B_16) break;
  343.         }
  344.     }
  345.   }
  346. }
  347.  
  348. void ScanTabs_CompressTables
  349. # ifdef __STDC__
  350. (SHORTINT Optimize)
  351. # else
  352. (Optimize)
  353. SHORTINT Optimize;
  354. # endif
  355. {
  356.   ScanTabs_TableRange base;
  357.   LONGINT lbase;
  358.   Dfa_DStateRange State;
  359.   BOOLEAN Success;
  360.   CHAR Ch, LastElmt;
  361.   LONGINT OldControlSize;
  362.   INTEGER i;
  363.   CARDINAL j;
  364.   SHORTINT Hash;
  365.   struct S_4 Group;
  366.   CARDINAL GroupCount;
  367.   struct S_6 Diffs;
  368.   CHAR StartCh, StopCh;
  369.   struct S_7 *HashTablePtr;
  370.   LONGINT HashTableSize;
  371.   DiffsInfoPtr Current;
  372.   Sets_tSet Domain;
  373.  
  374.   ScanTabs_BaseSize = Dfa_DStateCount + 1;
  375.   DynArray_MakeArray((ADDRESS *)&ScanTabs_BasePtr, &ScanTabs_BaseSize, (LONGINT)sizeof(ScanTabs_TableRange));
  376.   {
  377.     SHORTINT B_19 = 0, B_20 = Dfa_DStateCount;
  378.  
  379.     if (B_19 <= B_20)
  380.       for (State = B_19;; State += 1) {
  381.         ScanTabs_BasePtr->A[State] = 0;
  382.         if (State >= B_20) break;
  383.       }
  384.   }
  385.   if (Optimize == 0) {
  386.     ScanTabs_ControlSize = GenTabs_LeafCount * 60;
  387.   } else if (Optimize >= 10000) {
  388.     ScanTabs_ControlSize = Dfa_DStateCount * 5;
  389.   } else {
  390.     ScanTabs_ControlSize = GenTabs_LeafCount * 12;
  391.   }
  392.   ScanTabs_ControlSize = General_Max(ScanTabs_ControlSize, (LONGINT)ORD(Dfa_OldLastCh) + 1);
  393.   DynArray_MakeArray((ADDRESS *)&ScanTabs_ControlPtr, &ScanTabs_ControlSize, (LONGINT)sizeof(ScanTabs_ControlType));
  394.   {
  395.     LONGINT B_21 = 0, B_22 = ScanTabs_ControlSize - 1;
  396.  
  397.     if (B_21 <= B_22)
  398.       for (i = B_21;; i += 1) {
  399.         ScanTabs_ControlPtr->A[i].Check = Dfa_DNoState;
  400.         ScanTabs_ControlPtr->A[i].Next = Dfa_DNoState;
  401.         if (i >= B_22) break;
  402.       }
  403.   }
  404.   HashTableSize = Dfa_DStateCount;
  405.   DynArray_MakeArray((ADDRESS *)&HashTablePtr, &HashTableSize, (LONGINT)sizeof(DiffsInfoPtr));
  406.   {
  407.     LONGINT B_23 = 0, B_24 = HashTableSize - 1;
  408.  
  409.     if (B_23 <= B_24)
  410.       for (i = B_23;; i += 1) {
  411.         HashTablePtr->A[i] = NIL;
  412.         if (i >= B_24) break;
  413.       }
  414.   }
  415.   Sets_MakeSet(&Domain, ORD(Dfa_OldLastCh));
  416.   ScanTabs_TableSize = 0;
  417.   ScanTabs_TableEntries = 0;
  418.   Group.A[0].Last = '\0';
  419.   {
  420.     SHORTINT B_25 = 1, B_26 = Dfa_DStateCount;
  421.  
  422.     if (B_25 <= B_26)
  423.       for (State = B_25;; State += 1) {
  424.         Sets_AssignEmpty(&Domain);
  425.         Ch = Dfa_GetFirst(State);
  426.         LastElmt = Dfa_GetLast(State);
  427.         if (Ch <= LastElmt) {
  428.           for (;;) {
  429.             if (Dfa_GetTableNoDef(State, Ch) != Dfa_DNoState) {
  430.               if (Ch <= Classes_ClassCount) {
  431.                 Sets_Union(&Domain, Classes_ClassMemPtr->A[Ch]);
  432.               } else {
  433.                 Sets_Include(&Domain, ORD(Classes_ToChar.A[Ch]));
  434.               }
  435.             }
  436.             if (Ch == LastElmt) {
  437.               goto EXIT_1;
  438.             }
  439.             INC(Ch);
  440.           } EXIT_1:;
  441.         }
  442.         GroupCount = 0;
  443.         if (!Sets_IsEmpty(Domain)) {
  444.           Ch = CHR(Sets_Minimum(&Domain));
  445.           LastElmt = CHR(Sets_Maximum(&Domain));
  446.           if (Ch <= LastElmt) {
  447.             for (;;) {
  448.               for (;;) {
  449.                 if (Ch == LastElmt) {
  450.                   goto EXIT_3;
  451.                 }
  452.                 if (!Sets_IsElement(ORD(Ch), &Domain)) {
  453.                   INC(Ch);
  454.                 } else {
  455.                   goto EXIT_3;
  456.                 }
  457.               } EXIT_3:;
  458.               if (Sets_IsElement(ORD(Ch), &Domain)) {
  459.                 INC(GroupCount);
  460.                 Group.A[GroupCount].First = Ch;
  461.                 for (;;) {
  462.                   if (Ch == LastElmt) {
  463.                     goto EXIT_4;
  464.                   }
  465.                   if (Sets_IsElement(ORD(Ch), &Domain)) {
  466.                     INC(Ch);
  467.                   } else {
  468.                     goto EXIT_4;
  469.                   }
  470.                 } EXIT_4:;
  471.                 if (Sets_IsElement(ORD(Ch), &Domain)) {
  472.                   Group.A[GroupCount].Last = Ch;
  473.                 } else {
  474.                   Group.A[GroupCount].Last = CHR(ORD(Ch) - 1);
  475.                 }
  476.               }
  477.               if (Ch == LastElmt) {
  478.                 goto EXIT_2;
  479.               }
  480.             } EXIT_2:;
  481.           }
  482.         }
  483.         base = 0;
  484.         if (GroupCount > 0) {
  485.           Hash = 0;
  486.           {
  487.             LONGCARD B_27 = 1, B_28 = GroupCount;
  488.  
  489.             if (B_27 <= B_28)
  490.               for (j = B_27;; j += 1) {
  491.                 Diffs.A[j + j - 1] = CHR(ORD(Group.A[j].First) - ORD(Group.A[j - 1].Last));
  492.                 Diffs.A[j + j] = CHR(ORD(Group.A[j].Last) - ORD(Group.A[j].First));
  493.                 INC1(Hash, (ORD(Diffs.A[j + j - 1]) + ORD(Diffs.A[j + j])) * j);
  494.                 if (j >= B_28) break;
  495.               }
  496.           }
  497.           Hash = Hash % Dfa_DStateCount;
  498.           Success = FALSE;
  499.           Current = HashTablePtr->A[Hash];
  500.           for (;;) {
  501.             if (Current == NIL) {
  502.               goto EXIT_5;
  503.             }
  504.             if (Current->Count == GroupCount * 2) {
  505.               Success = TRUE;
  506.               j = 0;
  507.               for (;;) {
  508.                 INC(j);
  509.                 if (Current->DiffsPtr->A[j - 1] != Diffs.A[j]) {
  510.                   Success = FALSE;
  511.                   goto EXIT_6;
  512.                 }
  513.                 if (j == Current->Count) {
  514.                   goto EXIT_6;
  515.                 }
  516.               } EXIT_6:;
  517.               if (Success) {
  518.                 goto EXIT_5;
  519.               }
  520.             }
  521.             Current = Current->Next;
  522.           } EXIT_5:;
  523.           if (Success) {
  524.             base = Current->Base + ORD(Current->DiffsPtr->A[2 - 1]) + 1;
  525.           } else {
  526.             Current = (DiffsInfoPtr)Memory_Alloc((LONGINT)sizeof(DiffsInfo));
  527.             {
  528.               register DiffsInfo *W_1 = Current;
  529.  
  530.               W_1->Base = 0;
  531.               W_1->Next = HashTablePtr->A[Hash];
  532.               W_1->Count = GroupCount * 2;
  533.               W_1->DiffsPtr = (struct S_3 *)Memory_Alloc((LONGINT)W_1->Count);
  534.               {
  535.                 LONGCARD B_29 = 1, B_30 = W_1->Count;
  536.  
  537.                 if (B_29 <= B_30)
  538.                   for (j = B_29;; j += 1) {
  539.                     W_1->DiffsPtr->A[j - 1] = Diffs.A[j];
  540.                     if (j >= B_30) break;
  541.                   }
  542.               }
  543.             }
  544.             HashTablePtr->A[Hash] = Current;
  545.           }
  546.           for (;;) {
  547.             lbase = base;
  548.             if (lbase >= ScanTabs_ControlSize - (LONGINT)ORD(Dfa_OldLastCh)) {
  549.               OldControlSize = ScanTabs_ControlSize;
  550.               DynArray_ExtendArray((ADDRESS *)&ScanTabs_ControlPtr, &ScanTabs_ControlSize, (LONGINT)sizeof(ScanTabs_ControlType));
  551.               {
  552.                 LONGINT B_31 = OldControlSize, B_32 = ScanTabs_ControlSize - 1;
  553.  
  554.                 if (B_31 <= B_32)
  555.                   for (i = B_31;; i += 1) {
  556.                     ScanTabs_ControlPtr->A[i].Check = Dfa_DNoState;
  557.                     ScanTabs_ControlPtr->A[i].Next = Dfa_DNoState;
  558.                     if (i >= B_32) break;
  559.                   }
  560.               }
  561.             }
  562.             Success = TRUE;
  563.             j = 0;
  564.             for (;;) {
  565.               INC(j);
  566.               StartCh = Group.A[j].First;
  567.               StopCh = Group.A[j].Last;
  568.               Ch = StartCh;
  569.               for (;;) {
  570.                 if (ScanTabs_ControlPtr->A[base + ORD(Ch)].Check != Dfa_DNoState) {
  571.                   Success = FALSE;
  572.                   goto EXIT_9;
  573.                 }
  574.                 if (Ch == StopCh) {
  575.                   goto EXIT_9;
  576.                 }
  577.                 INC(Ch);
  578.               } EXIT_9:;
  579.               if (!Success || j == GroupCount) {
  580.                 goto EXIT_8;
  581.               }
  582.             } EXIT_8:;
  583.             if (Success) {
  584.               goto EXIT_7;
  585.             }
  586.             INC(base);
  587.           } EXIT_7:;
  588.           j = 0;
  589.           for (;;) {
  590.             INC(j);
  591.             Ch = Group.A[j].First;
  592.             StopCh = Group.A[j].Last;
  593.             for (;;) {
  594.               {
  595.                 register ScanTabs_ControlType *W_2 = &ScanTabs_ControlPtr->A[base + ORD(Ch)];
  596.  
  597.                 W_2->Check = State;
  598.                 W_2->Next = Dfa_GetTableNoDef(State, Classes_ToClass.A[Ch]);
  599.               }
  600.               INC(ScanTabs_TableEntries);
  601.               if (Ch == StopCh) {
  602.                 goto EXIT_11;
  603.               }
  604.               INC(Ch);
  605.             } EXIT_11:;
  606.             if (j == GroupCount) {
  607.               goto EXIT_10;
  608.             }
  609.           } EXIT_10:;
  610.           Current->Base = base;
  611.         }
  612.         ScanTabs_BasePtr->A[State] = base;
  613.         ScanTabs_TableSize = General_Max((LONGINT)ScanTabs_TableSize, (LONGINT)base);
  614.         if (State >= B_26) break;
  615.       }
  616.   }
  617.   INC1(ScanTabs_TableSize, ORD(Dfa_OldLastCh));
  618.   DynArray_ReleaseArray((ADDRESS *)&HashTablePtr, &HashTableSize, (LONGINT)sizeof(DiffsInfoPtr));
  619. }
  620.  
  621. void ScanTabs_WriteTables
  622. # ifdef __STDC__
  623. ()
  624. # else
  625. ()
  626. # endif
  627. {
  628.   Dfa_DStateRange State;
  629.  
  630.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"Tables :", 8L);
  631.   IO_WriteNl((System_tFile)IO_StdOutput);
  632.   IO_WriteNl((System_tFile)IO_StdOutput);
  633.   {
  634.     SHORTINT B_33 = 1, B_34 = Dfa_DStateCount;
  635.  
  636.     if (B_33 <= B_34)
  637.       for (State = B_33;; State += 1) {
  638.         WriteState(State);
  639.         IO_WriteNl((System_tFile)IO_StdOutput);
  640.         if (State >= B_34) break;
  641.       }
  642.   }
  643. }
  644.  
  645. void ScanTabs_QueryTables
  646. # ifdef __STDC__
  647. ()
  648. # else
  649. ()
  650. # endif
  651. {
  652.   Dfa_DStateRange State;
  653.  
  654.   for (;;) {
  655.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"State ? ", 8L);
  656.     if (IO_EndOfLine((System_tFile)IO_StdInput)) {
  657.       IO_ReadNl((System_tFile)IO_StdInput);
  658.     }
  659.     State = IO_ReadI((System_tFile)IO_StdInput);
  660.     if (State == 0) {
  661.       goto EXIT_12;
  662.     }
  663.     WriteState(State);
  664.   } EXIT_12:;
  665. }
  666.  
  667. static void WriteState
  668. # ifdef __STDC__
  669. (Dfa_DStateRange State)
  670. # else
  671. (State)
  672. Dfa_DStateRange State;
  673. # endif
  674. {
  675.   ScanTabs_TableElmt NextState;
  676.   CHAR Ch;
  677.   ScanTabs_ControlType ControlRecord;
  678.   INTEGER Count;
  679.  
  680.   Count = 0;
  681.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"State, Default =", 16L);
  682.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)State, 5L);
  683.   IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)ScanTabs_DefaultPtr->A[State], 5L);
  684.   IO_WriteNl((System_tFile)IO_StdOutput);
  685.   {
  686.     CHAR B_35 = Dfa_FirstCh, B_36 = Dfa_OldLastCh;
  687.  
  688.     if (B_35 <= B_36)
  689.       for (Ch = B_35;; Ch += 1) {
  690.         NextState = State;
  691.         for (;;) {
  692.           ControlRecord = ScanTabs_ControlPtr->A[ScanTabs_BasePtr->A[NextState] + ORD(Ch)];
  693.           if (ControlRecord.Check == NextState) {
  694.             NextState = ControlRecord.Next;
  695.             goto EXIT_13;
  696.           }
  697.           NextState = ScanTabs_DefaultPtr->A[NextState];
  698.           NextState = Dfa_DNoState;
  699.           if (NextState == Dfa_DNoState) {
  700.             goto EXIT_13;
  701.           }
  702.         } EXIT_13:;
  703.         if (NextState != Dfa_DNoState) {
  704.           if (Count == 10) {
  705.             IO_WriteNl((System_tFile)IO_StdOutput);
  706.             Count = 0;
  707.           }
  708.           INC(Count);
  709.           Layout_WriteChar((System_tFile)IO_StdOutput, Ch);
  710.           Layout_WriteSpace((System_tFile)IO_StdOutput);
  711.           IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)NextState, 1L);
  712.           IO_WriteC((System_tFile)IO_StdOutput, ',');
  713.           Layout_WriteSpace((System_tFile)IO_StdOutput);
  714.         }
  715.         if (Ch >= B_36) break;
  716.       }
  717.   }
  718.   IO_WriteNl((System_tFile)IO_StdOutput);
  719. }
  720.  
  721. void BEGIN_ScanTabs()
  722. {
  723.   static BOOLEAN has_been_called = FALSE;
  724.  
  725.   if (!has_been_called) {
  726.     has_been_called = TRUE;
  727.  
  728.     BEGIN_IO();
  729.     BEGIN_Checks();
  730.     BEGIN_General();
  731.     BEGIN_Memory();
  732.     BEGIN_DynArray();
  733.     BEGIN_Strings();
  734.     BEGIN_Idents();
  735.     BEGIN_Sets();
  736.     BEGIN_System();
  737.     BEGIN_IO();
  738.     BEGIN_Layout();
  739.     BEGIN_Dfa();
  740.     BEGIN_GenTabs();
  741.     BEGIN_Classes();
  742.     BEGIN_ScanGen();
  743.  
  744.     ElmtSize = sizeof(ScanTabs_TableElmt);
  745.   }
  746. }
  747.